/**
 * JZ UnoCSS - CSS自动生成器
 * 检查CSS文件并自动生成必要的CSS
 * @version 1.1.0
 * @author jz
 */

import { updateCSSFile, generateBasicCSS, generateMinimalCSS } from '../watchers/css-updater.js';
import { scanProjectFiles, extractClassNamesFromFile } from '../watchers/file-scanner.js';

/**
 * 检查并自动生成CSS文件
 * @param {string} cssPath - CSS文件路径
 * @param {Object} config - 配置对象
 * @param {boolean} force - 是否强制生成
 * @returns {boolean} 是否生成了CSS
 */
export function checkAndAutoGenerateCSS(cssPath, config = {}, force = false) {
    try {
        // 检查Node.js环境
        let fs;
        try {
            fs = require('fs');
        } catch (e) {
            return false;
        }
        
        // 检查CSS文件状态
        const fileExists = fs.existsSync(cssPath);
        let needsGeneration = false;
        let reason = '';
        
        if (!fileExists) {
            needsGeneration = true;
            reason = 'CSS文件不存在';
        } else if (force) {
            needsGeneration = true;
            reason = '强制重新生成';
        } else {
            // 检查文件内容
            try {
                const content = fs.readFileSync(cssPath, 'utf-8');
                if (content.trim().length < 100) {
                    needsGeneration = true;
                    reason = 'CSS文件内容过少';
                } else if (!content.includes('.flex') && !content.includes('.text-')) {
                    needsGeneration = true;
                    reason = 'CSS文件缺少基础样式';
                }
            } catch (readError) {
                needsGeneration = true;
                reason = 'CSS文件读取失败';
            }
        }
        
        if (needsGeneration) {
            console.log(`[JZ UnoCSS] 需要生成CSS的原因: ${reason}`);
            console.log(`[JZ UnoCSS] 为了避免覆盖现有CSS，跳过自动生成`);
            return false; // 禁用自动生成，避免覆盖现有CSS
            
            // 尝试生成CSS
            let generatedCSS = null;
            
            // 首先尝试基础CSS生成
            try {
                const basicClasses = ['flex', 'flex-col', 'items-center', 'justify-center', 'w-full', 'h-full', 'p-4', 'm-4', 'text-center', 'bg-white', 'text-black'];
                generatedCSS = generateBasicCSS(basicClasses, config);
            } catch (basicError) {
                // 基础CSS生成失败，尝试精确生成
                try {
                    generatedCSS = generatePreciseCSS(config);
                } catch (preciseError) {
                    // 所有生成方法失败，使用最基本的CSS
                    try {
                        generatedCSS = generateMinimalCSS(['flex', 'text-center', 'p-4'], config);
                    } catch (minimalError) {
                        generatedCSS = `/* JZ UnoCSS - Fallback CSS */
.flex { display: flex; }
.text-center { text-align: center; }
.p-4 { padding: 1rem; }
`;
                    }
                }
            }
            
            if (generatedCSS) {
                // 写入CSS文件
                const success = updateCSSFile(generatedCSS, config);
                if (success) {
                    // 验证生成的CSS
                    try {
                        const verifyContent = fs.readFileSync(cssPath, 'utf-8');
                        const ruleCount = (verifyContent.match(/\.[a-zA-Z]/g) || []).length;
                        
                        // 检查特定规则
                        const text16Match = verifyContent.match(/\.text-16[^{]*{[^}]*font-size:\s*([^;}]+)/);
                        if (text16Match) {
                            // text-16 字体大小验证通过
                        }
                    } catch (verifyError) {
                        console.warn('[JZ UnoCSS] ⚠️ 生成的CSS验证失败:', verifyError.message);
                    }
                    
                    return true;
                }
            }
            
            console.error('[JZ UnoCSS] ❌ 所有CSS生成方法都失败了');
            return false;
        } else {
            // CSS文件已存在且有内容，无需自动生成
            return false;
        }
    } catch (error) {
        console.error('[JZ UnoCSS] ❌ 检查/生成CSS文件时出错:', error);
        
        // 尝试最基本CSS生成作为错误恢复
        try {
            const recoveryCSS = generateMinimalCSS(['flex', 'text-center'], config);
            const success = updateCSSFile(recoveryCSS, config);
            if (success) {
                return true;
            }
        } catch (recoveryError) {
            console.error('[JZ UnoCSS] ❌ 错误恢复也失败了:', recoveryError.message);
        }
        
        return false;
    }
}

/**
 * 精确CSS生成（扫描项目文件）
 * @param {Object} config - 配置对象
 * @returns {string} CSS内容
 */
function generatePreciseCSS(config) {
    try {
        // 扫描项目文件
        const uvueFiles = scanProjectFiles(['.uvue']);
        
        if (uvueFiles.length === 0) {
            // 未找到.uvue文件，生成备用CSS
            return generateMinimalCSS(['flex', 'text-center', 'p-4', 'bg-white', 'text-black'], config);
        }
        
        // 提取所有类名和组合信息
        const allClassNames = new Set();
        const allClassNameGroups = [];
        let totalFilesProcessed = 0;
        
        for (const filePath of uvueFiles) {
            try {
                // 读取文件内容
                const fs = require('fs');
                const content = fs.readFileSync(filePath, 'utf-8');
                
                // 使用extractClassNamesWithContext提取类名和分组
                const { extractClassNamesWithContext } = require('../processors/processor.js');
                const { allClassNames: fileClassNames, classNameGroups: fileGroups } = extractClassNamesWithContext(content);
                
                fileClassNames.forEach(cls => allClassNames.add(cls));
                allClassNameGroups.push(...fileGroups);
                totalFilesProcessed++;
                
                // 限制处理文件数量以避免过长的处理时间
                if (totalFilesProcessed >= 10) break;
            } catch (error) {
                console.warn(`[JZ UnoCSS] 读取文件 ${filePath} 失败:`, error.message);
            }
        }
        
        const uniqueClassNames = Array.from(allClassNames);
        
        if (uniqueClassNames.length === 0) {
            return generateMinimalCSS(['flex', 'text-center'], config);
        }
        
        // 使用统一的CSS生成器，传入类名分组
        const { generateUnifiedCSS } = require('../core/unified-css-generator.js');
        const cssRules = generateUnifiedCSS(uniqueClassNames, allClassNameGroups, config);
        
        if (Array.isArray(cssRules) && cssRules.length > 0) {
            const cssContent = cssRules.join('\n\n') + '\n';
            return cssContent;
        } else {
            return generateMinimalCSS(uniqueClassNames.slice(0, 20), config);
        }
    } catch (error) {
        console.error('[JZ UnoCSS] 自动生成时出错:', error);
        return generateMinimalCSS(['flex', 'text-center'], config);
    }
}

// 函数已在定义时导出，无需重复导出 

/**
 * 自动生成精确的CSS
 * @param {Object} config - 配置对象
 * @returns {string} CSS内容
 */
export function autoGenerateAccurateCSS(config = {}) {
    try {
        return generatePreciseCSS(config);
    } catch (error) {
        console.error('[JZ UnoCSS] 自动生成精确CSS失败:', error);
        return generateMinimalCSS(['flex', 'text-center', 'p-4'], config);
    }
}

/**
 * 为ES模块生成CSS
 * @param {string[]} classNames - 类名数组
 * @param {Object} config - 配置对象
 * @returns {string} CSS内容
 */
export function generateCSSForESModule(classNames, config = {}) {
    try {
        if (!classNames || classNames.length === 0) {
            return generateMinimalCSS(['flex', 'text-center'], config);
        }
        
        // 对于ES模块，我们假设传入的是单独的类名，创建空的分组数组
        // 如果需要渐变支持，应该传入正确的类名分组
        const { generateUnifiedCSS } = require('../core/unified-css-generator.js');
        const cssRules = generateUnifiedCSS(classNames, [], config);
        
        if (Array.isArray(cssRules) && cssRules.length > 0) {
            const cssContent = cssRules.join('\n\n') + '\n';
            return cssContent;
        } else {
            return generateMinimalCSS(classNames, config);
        }
    } catch (error) {
        console.error('[JZ UnoCSS] ES模块CSS生成失败:', error);
        return generateMinimalCSS(['flex', 'text-center'], config);
    }
} 